Unsupervised learning on illicit trade data
Alice Lépissier
Bren School of Environmental Science and Management
Policy and media attention on illicit financial flows (IFF) has increased, with the recognition that Africa is a net creditor to the world.
 |
 |
| New York Times (2013) | Guardian (2015) |
 |
 |
| Guardian (2017) | Economist (2019) |
What is trade mis-invoicing?
- The deliberate mis-statement of price or quantity of internationally traded goods in invoices presented to customs
- Can occur at import or export
- Can result in an inflow or outflow of money
Motivations for trade mis-invoicing include:
- Evading tariffs
- Exploiting subsidy regimes
- Hiding transfers of wealth
Why does trade mis-invoicing matter?
- Outflows undermine the fiscal base and public spending
- Financing gap needed to meet the Sustainable Development Goals (SDGs)
- Combating trade mis-invoicing is crucial for the mobilization of domestic resources in the continent, and can catalyze sustainable development
Data source
- trade mis-invoicing data-set of the United Nations Economic Commission for Africa
- panel with $n=6,248,254$ of mis-invoiced trade between 179 reporting jurisdictions and 179 partner countries for years 2000-2016, disaggregated commodities (HS2 code)
Methodology for calculating mis-invoiced trade
- Locate mis-invoicing in the discrepancies between reported trade flows and their mirrored statistics
- But not all observed discrepancies are due to illicit motives!
- Imports tend to be recorded on the basis of Cost of Insurance and Freight (CIF), while exports are recorded Free On Board (FOB)
Our approach
- Estimate the discrepancies between imports and mirror net exports as a function of both licit and illicit predictors
- Perform a harmonization procedure in order to generate a reconciled value that represents our best estimate of what the legitimate value of the trade should be on a FOB basis
- Calculate the IFF embedded in each transaction as the difference between the observed value and the reconciled value
Zoom in on Africa
- During 2000-2016, the continent lost on average \$83 billion a year in gross illicit outflows
- Net cumulative flows during that period were \$362 billion
Goals
- Perform unsupervised learning on this data to extract meaningful insights
- Dimension reduction (PCA) - can I recover policy-relevant dimensions of variation?
Data wrangling¶
- Data-set of mis-invoiced trade by sector (unit of observation is reporter-year)
- View 1: unit of observation = reporter, features = sectors
- View 2: unit of observation = sectors, features = reporters
- Bilateral trade matrix (dyadic data)
Mis-invoiced trade for countries by sectors
In [6]:
IFF_Sector_Imp = IFF_Sector[['section', 'Imp_IFF_hi']]
IFF_Sector_Exp = IFF_Sector[['section', 'Exp_IFF_hi']]
IFF_Sector_Imp
Out[6]:
Mis-invoiced trade for dyads
In [9]:
IFF_Dest_Imp = IFF_Dest[['partner.ISO', 'Imp_IFF_hi']]
IFF_Dest_Exp = IFF_Dest[['partner.ISO', 'Exp_IFF_hi']]
IFF_Dest_Imp
Out[9]:
More data wrangling
In [11]:
crosswalk = pd.read_excel("Data/crosswalk.xlsx").rename(columns={'Country': 'country'})
crosswalk.head()
Out[11]:
Auxiliary functions¶
In [12]:
def create_features(data, values, features, obs):
"""
TODO: add doc string
"""
features_data = data.pivot_table(values=values,
columns=features,
index=[obs, 'year'],
fill_value=0)
return features_data
In [14]:
def biplot_PCA(features_data, nPC=2, firstPC=1, secondPC=2, obs='reporter.ISO', show_loadings=False):
"""Projects the data in the 2-dimensional space spanned by 2 principal components
chosen by the user, along with a bi-plot of the top 3 loadings per PC, and colors
by class label.
Args:
features_data: data-set of features
nPC: number of principal components
firstPC: integer denoting first principal component to plot in bi-plot
secondPC: integer denoting second principal component to plot in bi-plot
obs: string denoting index of class labels (in features_data)
show_loadings: Boolean indicating whether PCA loadings should be displayed
Returns:
plot (interactive)
pca_loadings (if show_loadings=True)
"""
# Run PCA (standardize data beforehand)
features_data_std = StandardScaler().fit_transform(features_data)
# features_data_std = power_transform(features_data, method='yeo-johnson', standardize=True)
pca = PCA(n_components=nPC, random_state=234)
princ_comp = pca.fit_transform(features_data_std)
# Extract PCA loadings
cols = ['PC' + str(c+1) for c in np.arange(nPC)]
pca_loadings = pd.DataFrame(pca.components_.T,
columns=cols,
index=list(features_data.columns))
# Extract PCA scores
pca_scores = pd.DataFrame(princ_comp,
columns=cols)
pca_scores[obs] = features_data.reset_index()[obs].values.tolist()
pca_scores['year'] = features_data.reset_index()['year'].values.tolist()
score_PC1 = princ_comp[:,firstPC-1]
score_PC2 = princ_comp[:,secondPC-1]
# Generate plot data
if obs == 'reporter.ISO':
plot_data = pd.merge(pca_scores, obs_info, on=[obs, 'year'])
color_obs = 'reporter'
tooltip_obs = ['reporter', 'year', 'Income group (World Bank)', 'Country status (UN)']
else:
plot_data = pca_scores
color_obs = 'section'
tooltip_obs = ['section', 'year']
# Return chosen PCs to plot
PC1 = 'PC'+str(firstPC)
PC2 = 'PC'+str(secondPC)
# Extract top loadings (in absolute value)
# TO DO: use dict to iterate over
toploadings_PC1 = pca_loadings.apply(lambda x: abs(x)).sort_values(by=PC1).tail(3)[[PC1, PC2]]
toploadings_PC2 = pca_loadings.apply(lambda x: abs(x)).sort_values(by=PC2).tail(3)[[PC1, PC2]]
originsPC1 = pd.DataFrame({'index':toploadings_PC1.index.tolist(),
PC1: np.zeros(3),
PC2: np.zeros(3)})
originsPC2 = pd.DataFrame({'index':toploadings_PC2.index.tolist(),
PC1: np.zeros(3),
PC2: np.zeros(3)})
toploadings_PC1 = pd.concat([toploadings_PC1.reset_index(), originsPC1], axis=0)
toploadings_PC2 = pd.concat([toploadings_PC2.reset_index(), originsPC2], axis=0)
toploadings_PC1[PC1] = toploadings_PC1[PC1]*max(score_PC1)*1.5
toploadings_PC1[PC2] = toploadings_PC1[PC2]*max(score_PC2)*1.5
toploadings_PC2[PC1] = toploadings_PC2[PC1]*max(score_PC1)*1.5
toploadings_PC2[PC2] = toploadings_PC2[PC2]*max(score_PC2)*1.5
# Project top 3 loadings over the space spanned by 2 principal components
lines = alt.Chart().mark_line().encode()
for color, i, dataset in zip(['#440154FF', '#21908CFF'], [0,1], [toploadings_PC1, toploadings_PC2]):
lines[i] = alt.Chart(dataset).mark_line(color=color).encode(
x= PC1 +':Q',
y= PC2 +':Q',
detail='index'
).properties(
width=500,
height=500
)
# Add labels to the loadings
text=alt.Chart().mark_text().encode()
for color, i, dataset in zip(['#440154FF', '#21908CFF'], [0, 1], [toploadings_PC1[0:3], toploadings_PC2[0:3]]):
text[i] = alt.Chart(dataset).mark_text(
align='left',
baseline='bottom',
color=color
).encode(
x= PC1 +':Q',
y= PC2 +':Q',
text='index'
)
# Scatter plot colored by observation class label
points = alt.Chart(plot_data).mark_circle(size=60).encode(
x=alt.X(PC1, axis=alt.Axis(title='Principal Component ' + str(firstPC))),
y=alt.X(PC2, axis=alt.Axis(title='Principal Component ' + str(secondPC))),
color=alt.Color(color_obs, scale=alt.Scale(scheme='category20b'),
legend=alt.Legend(orient='right')),
tooltip=tooltip_obs
).interactive()
# Bind it all together
chart = (points + lines[0] + lines[1] + text[0] + text[1])
chart.display()
if show_loadings:
return pca_loadings
In [15]:
def scree_plot(features_data, show_explained_var=False):
"""
TODO: add comments and docstring
"""
features_data_std = StandardScaler().fit_transform(features_data)
pca = PCA(n_components=features_data_std.shape[1], random_state=234)
princ_comp = pca.fit_transform(features_data_std)
explained_var = pd.DataFrame({'PC': np.arange(1,features_data_std.shape[1]+1),
'var': pca.explained_variance_ratio_,
'cumvar': np.cumsum(pca.explained_variance_ratio_)})
# Adapted from https://altair-viz.github.io/gallery/multiline_tooltip.html
# Create a selection that chooses the nearest point & selects based on x-value
nearest = alt.selection(type='single', nearest=True, on='mouseover',
fields=['PC'], empty='none')
# The basic line
line = alt.Chart(explained_var).mark_line(interpolate='basis', color='#FDE725FF').encode(
alt.X('PC:Q',
scale=alt.Scale(domain=(1, len(explained_var))),
axis=alt.Axis(title='Principal Component')
),
alt.Y('cumvar:Q',
scale=alt.Scale(domain=(min(explained_var['cumvar']), 1)),
axis=alt.Axis(title='Cumulative Variance Explained')
),
)
# Transparent selectors across the chart. This is what tells us
# the x-value of the cursor
selectors = alt.Chart(explained_var).mark_point().encode(
x='PC:Q',
opacity=alt.value(0),
).add_selection(
nearest
)
# Draw points on the line, and highlight based on selection
points = line.mark_point().encode(
opacity=alt.condition(nearest, alt.value(1), alt.value(0))
)
# Draw text labels near the points, and highlight based on selection
text = line.mark_text(align='left', dx=5, dy=-5).encode(
text=alt.condition(nearest, 'cumvar:Q', alt.value(' '))
)
# Draw a rule at the location of the selection
rules = alt.Chart(explained_var).mark_rule(color='gray').encode(
x='PC:Q',
).transform_filter(
nearest
)
# Put the five layers into a chart and bind the data
out = alt.layer(
line, selectors, points, rules, text
).properties(
title='Cumulative scree plot',
width=600, height=300
)
out.display()
if show_explained_var:
return explained_var[['PC', 'var']]
PCA on feature space (for individual reporting countries)¶
Sector features¶
In [16]:
sector_features = create_features(IFF_Sector_Imp, 'Imp_IFF_hi',
features='section', obs='reporter.ISO')
sector_features
Out[16]:
Biplots¶
In [17]:
biplot_PCA(sector_features, 10, 1, 2, obs='reporter.ISO', show_loadings=True)
Out[17]:
In [18]:
biplot_PCA(sector_features, 10, 3, 4, obs='reporter.ISO')
In [19]:
biplot_PCA(sector_features, 10, 5, 6, obs='reporter.ISO')
Explained variance¶
In [20]:
scree_plot(sector_features, show_explained_var=True)
Out[20]:
In [25]:
biplot_PCA(sector_features, 10, 1, 2, obs='reporter.ISO')
Country features¶
In [28]:
country_features = create_features(IFF_Sector_Imp, 'Imp_IFF_hi',
features='reporter.ISO', obs='section')
country_features
Out[28]:
Biplots¶
In [29]:
biplot_PCA(country_features, 10, 1, 2, obs='section', show_loadings=True)
Out[29]:
In [30]:
biplot_PCA(country_features, 10, 3, 4, obs='section')
In [31]:
biplot_PCA(country_features, 10, 5, 6, obs='section')
Explained variance¶
In [32]:
scree_plot(country_features)
Variance-stabilizing and normalizing transformations¶
In [35]:
# fig, axes = joypy.joyplot(country_features.iloc[:,0:22], colormap=plt.cm.magma, figsize=(8,8));
# fig, axes = joypy.joyplot(country_features.iloc[:,22:47], colormap=plt.cm.magma, figsize=(8,8));
In [36]:
country_features_log = country_features.apply(lambda x: np.log(x+1) if np.issubdtype(x.dtype, np.number) else x, axis=0)
In [37]:
# fig, axes = joypy.joyplot(country_features_log.iloc[:,0:22], colormap=plt.cm.magma, figsize=(8,8));
# fig, axes = joypy.joyplot(country_features_log.iloc[:,22:47], colormap=plt.cm.magma, figsize=(8,8));
In [38]:
country_features_yeo = power_transform(country_features, method='yeo-johnson', standardize=True)
country_features_yeo = pd.DataFrame(country_features_yeo,
index=country_features.index,
columns=country_features.columns)
# fig, axes = joypy.joyplot(country_features_yeo.iloc[:,0:22], colormap=plt.cm.magma, figsize=(8,8));
# fig, axes = joypy.joyplot(country_features_yeo.iloc[:,22:47], colormap=plt.cm.magma, figsize=(8,8));
In [39]:
biplot_PCA(country_features_log, 10, 1, 2, obs='section')
In [40]:
biplot_PCA(country_features_yeo, 10, 1, 2, obs='section')
PCA on bilateral trade matrix¶
In [41]:
partner_features = create_features(IFF_Dest_Imp, 'Imp_IFF_hi',
features='partner.ISO', obs='reporter.ISO')
partner_features
Out[41]:
Biplots¶
In [42]:
biplot_PCA(partner_features, 10, 1, 2, show_loadings=True)
Out[42]:
In [43]:
biplot_PCA(partner_features, 10, 3, 4)
In [44]:
biplot_PCA(partner_features, 10, 5, 6)
Explained variance¶
In [45]:
scree_plot(partner_features)
Intra-African illicit financial flows¶
In [55]:
partner_features_AFR = create_features(IFF_Dest_Imp_AFR, 'Imp_IFF_hi',
features='partner.ISO', obs='reporter.ISO')
partner_features_AFR
Out[55]:
In [59]:
biplot_PCA(partner_features_AFR, partner_features_AFR.shape[1], 1, 2)
Remove outliers¶
In [60]:
features_data_std = StandardScaler().fit_transform(partner_features_AFR)
pca = PCA(n_components=partner_features_AFR.shape[1])
princ_comp = pca.fit_transform(features_data_std)
#outlying = (princ_comp[:,44] > 1.5) | (princ_comp[:,45] > 3e-15)
#outlying = (princ_comp[:,44] > 0.5) | (princ_comp[:,45] > 1.5e-15)
outlying = (princ_comp[:,0] > 6) | (princ_comp[:,1] > 4)
partner_features_AFR[outlying].index
Out[60]:
In [61]:
partner_features_AFR_noout = partner_features_AFR[~outlying]
In [62]:
biplot_PCA(partner_features_AFR_noout, 46, 1, 2)
Coloring by class label¶
In [65]:
biplot_PCA_classes(sector_features, 21, 1, 2, classes='UN_Intermediate_Region')
In [66]:
biplot_PCA_classes(sector_features, 21, 1, 2, classes='Income group (World Bank)')
In [67]:
biplot_PCA_classes(partner_features, 46, 1, 2)
In [68]:
biplot_PCA_classes(partner_features, 46, 1, 2, classes='Income group (World Bank)')
In [69]:
biplot_PCA_classes(partner_features_AFR, 46, 1, 2)
In [70]:
biplot_PCA_classes(partner_features_AFR, 46, 1, 2, classes='Income group (World Bank)')
In [71]:
biplot_PCA_classes(partner_features_AFR_noout, 46, 1, 2)
In [72]:
biplot_PCA_classes(partner_features_AFR_noout, 46, 1, 2, classes='Income group (World Bank)')
Hierarchical clustering and corresponding heatmap¶
In [76]:
# Create data for African bilateral trade matrix in 2016
data = partner_features_AFR_noout.reset_index() \
.query('year == "2016"').drop(columns='year').set_index('reporter.ISO')
# Select the columns which have at least 1 non-zero row
data = data.loc[:,(data != 0).any(axis=0)]
# Log the data
data = data.apply(lambda x: np.log10(x+1) if np.issubdtype(x.dtype, np.number) else x, axis=0)
# Scale the data
scaler = StandardScaler()
# scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data)
data_scaled = pd.DataFrame(data_scaled, index=data.index, columns=data.columns)
# Extract region labels for the observations
obs_labels = region_labels(data).set_index('reporter.ISO')
# Extract unique regions
color_labels = obs_labels['UN_Intermediate_Region'].unique()
color_labels = np.sort(color_labels)
# List of RGB triplets for the region labels
rgb_values = sns.color_palette('Paired', 5)
# Map region labels to RGB triplet
color_map = dict(zip(color_labels, rgb_values))
region_color = pd.DataFrame(obs_labels)['UN_Intermediate_Region'].map(color_map)
In [77]:
# Plot heatmap and corresponding dendograms
g = sns.clustermap(data_scaled,
method='ward',
cmap='bone_r',
row_colors=region_color,
);
g.fig.suptitle('Hierarchical clustering with Ward linkage', y=1);
Concluding thoughts
- Target 16.4 of the SDGs: "By 2030, significantly reduce illicit financial and arms flows, strengthen the recovery and return of stolen assets and combat all forms of organized crime"
- Increasing international policy attention to the problem has lead to demands for more accurate estimates.
- Accurate estimates of the nature and of the scale of the problem can support policy prioritization and targeted intervention to combat illicit flows.
Next steps
- hierarchical clustering (and reordered heatmap)
- explore clustering a bit more
- NMF on bilateral trade matrix which also includes sectors, so unit of observation is dyad, and features are sectors
- Merge in GDP and (maybe?) distance measures to see if NMF recovers gravity interpretation of international trade
Network analysis¶
Data wrangling¶
In [83]:
indicators = {'CC.PER.RNK': 'control-corruption',
'RL.PER.RNK': 'rule-of-law',
'NY.GDP.PCAP.CD': 'gdp-pc',
'SP.RUR.TOTL.ZS': 'rural-pop',
'AG.LND.AGRI.ZS' : 'agric-land'}
covariates = wb.get_dataframe(indicators,
data_date=(datetime.datetime(2016, 1, 1)))
covariates
Out[83]:
In [84]:
covariates = pd.merge(left=covariates.reset_index().rename(columns={'index': 'country'}),
right=crosswalk[['country', 'ISO3166.3']],
how='left', on='country').rename(columns={'date': 'year'})
covariates = covariates.dropna(subset=['ISO3166.3']).set_index('ISO3166.3')
In [85]:
def create_graph_data(year='2016', threshold=True, threshold_var='GDP', flow_threshold=10000):
"""TO DO: add doc string and comments"""
flow_data = IFF_Dest.reset_index().query('year == @year')
flow_data = flow_data.loc[flow_data['Imp_IFF_hi'].notnull(), :]
flow_data = flow_data.query('Imp_IFF_hi >= @flow_threshold')
if threshold:
conduits = 'conduits_' + threshold_var
flow_data = flow_data[flow_data['reporter.ISO'].isin(eval(conduits).index)]
return flow_data
Thresholding¶
In [86]:
panel = pyreadr.read_r('Data/GER_Orig_Year_Africa.Rdata')
IFF_Year = panel['GER_Orig_Year_Africa']
In [87]:
IFF_Year = IFF_Year.query('year == "2016"')
sns.distplot(IFF_Year['Tot_IFF_hi_GDP'], kde=True, label='% GDP', bins=10);
sns.distplot(IFF_Year['Tot_IFF_hi_trade'], kde=True, label='% trade', bins=10);
plt.legend()
plt.title('Distribution of IFF in Africa in 2016')
plt.xlabel('Mis-invoiced trade for African countries');
In [88]:
thresh_GDP = 0.1
thresh_trade = 0.18
conduits_GDP = IFF_Year.query('Tot_IFF_hi_GDP >= @thresh_GDP').set_index('reporter.ISO')
conduits_trade = IFF_Year.query('Tot_IFF_hi_trade >= @thresh_trade').set_index('reporter.ISO')
In [89]:
conduits_GDP
Out[89]:
In [90]:
conduits_trade
Out[90]:
In [91]:
flow_data = create_graph_data('2016', threshold_var='trade')
In [92]:
panel = pyreadr.read_r('Data/GER_Orig_Dest_Year_std.Rdata')
IFF_std = panel['GER_Orig_Dest_Year_std']
IFF_std = IFF_std.query('year == "2016"')
IFF_std.describe()
Out[92]:
In [93]:
flow_data = pd.merge(left=flow_data,
right=IFF_std[['reporter.ISO', 'partner.ISO', 'pImp_IFF_hi_GDP']],
on=['reporter.ISO', 'partner.ISO'])
sns.distplot(flow_data['pImp_IFF_hi_GDP'], kde=True);
plt.title('Distribution of IFF in partner countries')
plt.xlabel('Mis-invoiced trade as proportion of GDP in partner countries');
In [94]:
flow_data = flow_data.query('pImp_IFF_hi_GDP >= 0.0001')
Create directed graph¶
In [95]:
graph = nx.from_pandas_edgelist(flow_data,
'reporter.ISO',
'partner.ISO',
'Imp_IFF_hi',
create_using = nx.DiGraph())
In [96]:
# Check the number of unique reporters and partners
pd.unique(flow_data[['reporter.ISO', 'partner.ISO']].values.ravel('K'))
len(pd.unique(flow_data[['reporter.ISO', 'partner.ISO']].values.ravel('K')))
Out[96]:
In [97]:
# Check the number of nodes and edges in the graph
len(graph.nodes()), len(graph.edges())
Out[97]:
In [98]:
# Print some of the edges in the network
list(graph.edges(data=True))[0:10]
Out[98]:
In [99]:
# Get the degree of the nodes
graph.degree
Out[99]:
In [100]:
# Create dictionary of GDP per capita for each country
GDP_attr = covariates.loc[:, ['gdp-pc']]
GDP_attr = GDP_attr.to_dict('index')
list(GDP_attr.items())[0:10]
Out[100]:
In [101]:
# Set GDP per capita as a node attribute
nx.set_node_attributes(graph, GDP_attr)
list(graph.nodes(data=True))[0:10]
Out[101]:
In [102]:
graph.nodes['MLI']
Out[102]:
In [103]:
graph.nodes['MLI']['gdp-pc']
Out[103]:
In [104]:
# Create dictionary of longitude and latitude for countries
pos = {country: (v['Longitude'], v['Latitude'])
for country, v in
crosswalk.drop_duplicates('ISO3166.3').set_index('ISO3166.3').to_dict('index').items()
}
list(pos.items())[0:10]
Out[104]:
In [105]:
# Create list of colors for nodes in the graph
col = [nx.get_node_attributes(graph, 'gdp-pc')[n] for n in graph.nodes]
print(np.min(col), np.max(col))
In [106]:
# Create list of colors for edges in the graph
edge_col = [nx.get_edge_attributes(graph, 'Imp_IFF_hi')[e] for e in graph.edges]
edge_col = np.log(edge_col)
In [107]:
# Draw directed graph and color nodes by GDP per capita
plt.figure(figsize = (10,10))
nx.draw_networkx(graph,
# width=0.5,
node_color=col, cmap=plt.cm.spring_r,
edge_color=edge_col, edge_cmap=plt.cm.get_cmap('RdPu'))
plt.show();
In [108]:
# Extract outdegree (the number of edges coming out of nodes) and degree
outdeg = graph.out_degree
deg = graph.degree
# Size of nodes will be proportional to their degree
sizes = [10 * deg[c] for c in graph.nodes]
# Label the countries if their outdegree is at least 1, i.e. if they are the reporting African countries
labels = {c: c if outdeg[c] >= 1 else ''
for c in graph.nodes}
In [109]:
# Map projection
crs = ccrs.PlateCarree()
fig, ax = plt.subplots(1, 1, figsize=(20, 8), subplot_kw=dict(projection=crs))
ax.coastlines(color='lightgray')
ax.add_feature(cfeature.LAND, facecolor='lightgray')
ax.add_feature(cfeature.BORDERS, edgecolor='white')
# ax.set_extent([-160, 180, -60, 90], crs=ccrs.PlateCarree())
# Overlay network graph
nx.draw_networkx(graph, ax=ax,
pos=pos,
font_size=14,
alpha=0.7,
# width=0.5,
node_color=col, cmap=plt.cm.spring_r,
edge_color=edge_col, edge_cmap=plt.cm.get_cmap('RdPu'),
node_size=sizes,
labels=labels)
